home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / unixSyscall / compatSig.c < prev    next >
C/C++ Source or Header  |  1990-06-26  |  5KB  |  221 lines
  1. /*
  2.  * compatSig.c --
  3.  *
  4.  *     Returns the Sprite signal number corresponding to a Unix signal.
  5.  *
  6.  * Copyright (C) 1986 Regents of the University of California
  7.  * All rights reserved.
  8.  *
  9.  */
  10.  
  11. #ifndef lint
  12. static char rcsid[] = "$Header: /sprite/src/lib/c/unixSyscall/RCS/compatSig.c,v 1.8 90/06/26 18:41:03 douglis Exp $ SPRITE (Berkeley)";
  13. #endif not lint
  14.  
  15. #include "sprite.h"
  16.  
  17. #ifndef NULL
  18. #define NULL 0
  19. #endif
  20.  
  21. #include "compatInt.h"
  22. #include <sig.h>
  23. #include <signal.h>
  24.  
  25. #include "compatSig.h"
  26.  
  27.  
  28. /*
  29.  *----------------------------------------------------------------------
  30.  *
  31.  * Compat_UnixSignalToSprite --
  32.  *
  33.  *    Given a Unix signal, return the closest corresponding Sprite signal
  34.  *    number. Signal 0 is special-cased to map to sprite signal 0 (NULL).
  35.  *    Some programs use kill(pid, 0) to see if pid exists....
  36.  *
  37.  * Results:
  38.  *    A Sprite signal number is returned, assuming the Unix signal is
  39.  *    in a valid range.  Note that the Sprite "signal number" may be
  40.  *    NULL (0) if there's no matching signal.
  41.  *
  42.  * Side effects:
  43.  *    None.
  44.  *
  45.  *----------------------------------------------------------------------
  46.  */
  47.  
  48. ReturnStatus
  49. Compat_UnixSignalToSprite(signal, spriteSigPtr)
  50.     int signal;
  51.     int *spriteSigPtr;
  52. {
  53.     if (signal >= 0 && signal <= NSIG) {
  54.     *spriteSigPtr = compat_UnixSigToSprite[signal];
  55.     return(SUCCESS);
  56.     } else {
  57.     return(FAILURE);
  58.     }
  59. }
  60.  
  61.  
  62. /*
  63.  *----------------------------------------------------------------------
  64.  *
  65.  * Compat_SpriteSignalToUnix --
  66.  *
  67.  *    Given a Sprite signal, return the closest corresponding Unix signal
  68.  *    number.
  69.  *
  70.  * Results:
  71.  *    A Unix signal number is returned, assuming the Sprite signal is
  72.  *    in a valid range. 
  73.  *
  74.  * Side effects:
  75.  *    None.
  76.  *
  77.  *----------------------------------------------------------------------
  78.  */
  79. ReturnStatus
  80. Compat_SpriteSignalToUnix(signal, unixSigPtr)
  81.     int signal;
  82.     int *unixSigPtr;
  83. {
  84.     if (signal >= 0 && signal <= SIG_NUM_SIGNALS) {
  85.     *unixSigPtr = spriteToUnix[signal];
  86.     return(SUCCESS);
  87.     } else {
  88.     return(FAILURE);
  89.     }
  90. }
  91.  
  92.  
  93. /*
  94.  *----------------------------------------------------------------------
  95.  *
  96.  *  Compat_UnixSigMaskToSprite --
  97.  *
  98.  *    Given a Unix signal mask, return the corresponding Sprite signal
  99.  *    mask.
  100.  *
  101.  * Results:
  102.  *    A Sprite signal mask is returned, assuming the Unix signal mask is
  103.  *    valid.
  104.  *
  105.  * Side effects:
  106.  *    None.
  107.  *
  108.  *----------------------------------------------------------------------
  109.  */
  110.  
  111. ReturnStatus
  112. Compat_UnixSigMaskToSprite(unixMask, spriteMaskPtr)
  113.     int unixMask;
  114.     int *spriteMaskPtr;
  115. {
  116.     int i;
  117.     int signal;
  118.     ReturnStatus status;
  119.  
  120.     *spriteMaskPtr = 0;
  121.     for (i = 1; i < NSIG; i++) {
  122.     if (unixMask & (1 << (i - 1))) {
  123.         status = Compat_UnixSignalToSprite(i, &signal);
  124.         if (status == FAILURE) {
  125.         return(FAILURE);
  126.         }
  127.         if (signal != NULL) {
  128.         *spriteMaskPtr |= 1 << (signal - 1);
  129.         }
  130.     }
  131.     }
  132. #ifdef COMPAT_DEBUG
  133.     Io_Print("Unix mask = <%x> Sprite mask = <%x>\n", 
  134.         unixMask, *spriteMaskPtr);
  135. #endif
  136.     return(SUCCESS);
  137. }
  138.  
  139.  
  140. /*
  141.  *----------------------------------------------------------------------
  142.  *
  143.  * Compat_SpriteSigMaskToUnix --
  144.  *
  145.  *    Given a Sprite signal mask, return the corresponding Unix signal
  146.  *    mask.
  147.  *
  148.  * Results:
  149.  *    A Unix signal mask is returned, assuming the Sprite signal mask is
  150.  *    valid.
  151.  *
  152.  * Side effects:
  153.  *    None.
  154.  *
  155.  *----------------------------------------------------------------------
  156.  */
  157.  
  158. ReturnStatus
  159. Compat_SpriteSigMaskToUnix(SpriteMask, UnixMaskPtr)
  160.     int SpriteMask;
  161.     int *UnixMaskPtr;
  162. {
  163.     int i;
  164.     int signal;
  165.     ReturnStatus status;
  166.  
  167.     *UnixMaskPtr = 0;
  168.     for (i = 1; i <= SIG_NUM_SIGNALS; i++) {
  169.     if (SpriteMask & (1 << (i - 1))) {
  170.         status = Compat_SpriteSignalToUnix(i, &signal);
  171.         if (status == FAILURE) {
  172.         return(FAILURE);
  173.         }
  174.         if (signal != NULL) {
  175.         *UnixMaskPtr |= 1 << (signal - 1);
  176.         }
  177.     }
  178.     }
  179.     return(SUCCESS);
  180. }
  181.  
  182.  
  183. /*
  184.  *----------------------------------------------------------------------
  185.  *
  186.  * Compat_GetSigHoldMask --
  187.  *
  188.  *    Return the current signal mask.
  189.  *
  190.  * Results:
  191.  *    The current signal mask (in Sprite terms) is returned.
  192.  *
  193.  * Side effects:
  194.  *    None.
  195.  *
  196.  *----------------------------------------------------------------------
  197.  */
  198.  
  199. #define MASK_ALL_SIGNALS 0xFFFFFFFF
  200.  
  201. ReturnStatus
  202. Compat_GetSigHoldMask(maskPtr)
  203.     int *maskPtr;
  204. {
  205.     ReturnStatus status;
  206.  
  207.     /*
  208.      * To modify the hold mask we need to get the old one by
  209.      * calling Sig_SetHoldMask to get the current mask.  Since we
  210.      * don't know what to set the mask to, set the mask to mask ALL 
  211.      * signals and then reset it again to the proper value.
  212.      */
  213.  
  214.     status = Sig_SetHoldMask((int) MASK_ALL_SIGNALS, maskPtr);
  215.     if (status != SUCCESS) {
  216.     return(status);
  217.     }
  218.     status = Sig_SetHoldMask(*maskPtr, (int *) NULL);
  219.     return(status);
  220. }
  221.